/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: mac
 * Date: 2022-10-26
 * Time: 19:38
 */
interface A {

}
class OutterClass {
    public int data1 = 1;
    public int data2 = 2;
    public static int data3 = 3;

    //实例内部类:你可以把他当做 是外部类的一个普通实例成员
    //1.在其中不可以定义一个静态的成员变量！跟下面一样，非要定义只能定义一个静态常量
    //2.如何实例化内部类对象
    //3.如果内部类中包含了与外部类同名成员变量，如何访问
    //4.包含两个this,一个是自己的this，一个是外部类的this
    class InnerClass implements A{
        class Inner {

        }

        public int data1 = 999999;
        public int data4 = 4;
        private int data5 = 5;
        public static final int data6 = 6;


        public InnerClass(){
            System.out.println("不带参数的内部类的构造方法！");
        }

        public void test(){
            System.out.println(OutterClass.this.data1);
            System.out.println(data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
            System.out.println("InnerClass::test");
        }
    }

    public void func1() {
        //static int a = 10;//属于本类的 不属于对象的
        System.out.println("OuterClass::func1");
    }
}

// 链表类 是由 节点类 组成的
class MyLinkedList {
    class Node{

    }
}
public class TestDemo extends OutterClass.InnerClass{
    //继承内部类时，需要在构造方法中加入以下内容
    public TestDemo(OutterClass outterClass) {
        outterClass.super();
    }
    /*public void func() {
        class Test {
            public int a;
        }
        //缺点：只能在当前方法中使用
    }*/

    public static void main(String[] args) {
        OutterClass outterClass = new OutterClass();
        outterClass.func1();

        //外部类.内部类 内部类对象 = 外部类对象.new 内部类
        OutterClass.InnerClass innerClass = outterClass.new InnerClass();
        innerClass.test();
    }
}
